{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import shutil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision import datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VGG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/miniVGG.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBlock(nn.Sequential):\n",
    "    def __init__(self, in_channels, out_channels, pool=True, drop_rate=0.):\n",
    "        super().__init__()\n",
    "        # 模块：二维卷积\n",
    "        self.add_module('conv', nn.Conv2d(in_channels, out_channels,\n",
    "                                          kernel_size=3, padding=1, bias=True))\n",
    "        # 模块：激活函数\n",
    "        self.add_module('relu', nn.ReLU(inplace=True))\n",
    "        # 模块：Normalization\n",
    "        self.add_module('norm', nn.BatchNorm2d(out_channels))\n",
    "        # 模块：池化层\n",
    "        if pool:\n",
    "            self.add_module('pool', nn.MaxPool2d(kernel_size=2))\n",
    "        if drop_rate > 0:\n",
    "            self.add_module('dropout', nn.Dropout(p=drop_rate)) \n",
    "    # 可写可不写：\n",
    "    def forward(self, x):\n",
    "        return super().forward(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConvBlock(\n",
      "  (conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (relu): ReLU(inplace=True)\n",
      "  (norm): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      ")\n",
      "torch.Size([5, 3, 32, 32]) torch.Size([5, 32, 16, 16])\n"
     ]
    }
   ],
   "source": [
    "# 验证\n",
    "conv_block = ConvBlock(3,32)\n",
    "print(conv_block)\n",
    "x = torch.randn(5,3,32,32)\n",
    "y = conv_block(x)\n",
    "print(x.shape,y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FCBlock(nn.Sequential):\n",
    "    def __init__(self, dim_in, dim_out, drop_rate=0.):\n",
    "        super().__init__()\n",
    "        self.add_module('fc', nn.Linear(dim_in, dim_out))\n",
    "        self.add_module('relu', nn.ReLU(inplace=True))\n",
    "        self.add_module('norm', nn.BatchNorm1d(dim_out))\n",
    "        if drop_rate > 0:\n",
    "            self.add_module('dropout', nn.Dropout(p=drop_rate))\n",
    "            \n",
    "    def forward(self, x):\n",
    "        return super().forward(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FCBlock(\n",
      "  (fc): Linear(in_features=400, out_features=5, bias=True)\n",
      "  (relu): ReLU(inplace=True)\n",
      "  (norm): BatchNorm1d(5, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      ")\n",
      "torch.Size([5, 400]) torch.Size([5, 5])\n"
     ]
    }
   ],
   "source": [
    "fc_block = FCBlock(400,5)\n",
    "print(fc_block)\n",
    "x = torch.randn(5,400)\n",
    "y = fc_block(x)\n",
    "print(x.shape,y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MiniVGG(nn.Module):\n",
    "    def __init__(self, drop_rate=0.):\n",
    "        super().__init__()\n",
    "        self.conv = nn.Sequential()\n",
    "        self.conv.add_module('block1', ConvBlock(3,  32,\n",
    "                                                 pool=False))\n",
    "        self.conv.add_module('block2', ConvBlock(32, 32,\n",
    "                                                 pool=True,  drop_rate=drop_rate))\n",
    "        self.conv.add_module('block3', ConvBlock(32, 64,\n",
    "                                                 pool=False))\n",
    "        self.conv.add_module('block4', ConvBlock(64, 64,\n",
    "                                                 pool=True, drop_rate=drop_rate))\n",
    "\n",
    "        self.fc = nn.Sequential()\n",
    "        self.fc.add_module('fc_block', FCBlock(4096, 512, drop_rate=drop_rate))\n",
    "        self.fc.add_module('last_layer', nn.Linear(512, 10))\n",
    "\n",
    "    @property\n",
    "    def model_size(self):\n",
    "        n_params = 0\n",
    "        for param in self.parameters():\n",
    "            n_params += param.numel()\n",
    "        return n_params\n",
    "            \n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = x.view(-1, 4096)\n",
    "        out = self.fc(x)\n",
    "        return out\n",
    "\n",
    "    def forward_test(self, x):\n",
    "        print(f\"{'input':<15}: {str(x.data.shape):>20}\")\n",
    "        for name, module in self.conv._modules.items():\n",
    "            x = module(x)\n",
    "            print(f\"{name:<15}: {str(x.data.shape):>20}\")\n",
    "        x = x.view(-1, 4096)\n",
    "        for name, module in self.fc._modules.items():\n",
    "            x = module(x)\n",
    "            print(f\"{name:<15}: {str(x.data.shape):>20}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2169770\n",
      "8.277015686035156 MB\n"
     ]
    }
   ],
   "source": [
    "vgg = MiniVGG()\n",
    "print(vgg.model_size)\n",
    "print(f'{vgg.model_size * 4 / 1024**2} MB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input          : torch.Size([5, 3, 32, 32])\n",
      "block1         : torch.Size([5, 32, 32, 32])\n",
      "block2         : torch.Size([5, 32, 16, 16])\n",
      "block3         : torch.Size([5, 64, 16, 16])\n",
      "block4         : torch.Size([5, 64, 8, 8])\n",
      "fc_block       : torch.Size([5, 512])\n",
      "last_layer     :  torch.Size([5, 10])\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(5, 3, 32, 32)\n",
    "y = vgg.forward_test(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ResNet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/resnet18.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/resblock.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Module):\n",
    "    \"\"\"ResidualBlock\"\"\"\n",
    "    expansion = 1\n",
    "    def __init__(self, in_channel, out_channel, stride=1):\n",
    "        super().__init__()\n",
    "        self.conv = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, padding=1, bias=False),\n",
    "                                  nn.BatchNorm2d(out_channel),\n",
    "                                  nn.ReLU(inplace=True),\n",
    "                                  nn.Conv2d(out_channel, out_channel, kernel_size=3, stride=1, padding=1, bias=False),\n",
    "                                  nn.BatchNorm2d(out_channel))\n",
    "        self.shortcut = nn.Sequential()\n",
    "        if in_channel != out_channel:\n",
    "            self.shortcut = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, bias=False),\n",
    "                                          nn.BatchNorm2d(out_channel))\n",
    "    def forward(self, x):\n",
    "        identity = self.shortcut(x)\n",
    "        out = self.conv(x)        \n",
    "        out += identity\n",
    "        out = F.relu(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResidualBlock(\n",
      "  (conv): Sequential(\n",
      "    (0): Conv2d(4, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU(inplace=True)\n",
      "    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  )\n",
      "  (shortcut): Sequential(\n",
      "    (0): Conv2d(4, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  )\n",
      ")\n",
      "torch.Size([4, 4, 32, 32]) torch.Size([4, 64, 16, 16])\n"
     ]
    }
   ],
   "source": [
    "block = ResidualBlock(4, 64, 2)\n",
    "print(block)\n",
    "x = torch.randn(4, 4, 32, 32)\n",
    "y = block(x)\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bottleneck(nn.Module):\n",
    "    \"\"\"Bottleneck\"\"\"\n",
    "    expansion = 4\n",
    "    def __init__(self, in_channel, out_channel, stride=1):\n",
    "        super().__init__()\n",
    "        channel = out_channel // self.expansion\n",
    "        self.conv = nn.Sequential(nn.Conv2d(in_channel, channel, kernel_size=1, stride=1, padding=0, bias=False),\n",
    "                                  nn.BatchNorm2d(channel),\n",
    "                                  nn.ReLU(inplace=True),\n",
    "                                  nn.Conv2d(channel, channel, kernel_size=3, stride=stride, padding=1, bias=False),\n",
    "                                  nn.BatchNorm2d(channel),\n",
    "                                  nn.ReLU(inplace=True),\n",
    "                                  nn.Conv2d(channel, out_channel, kernel_size=1, stride=1, padding=0, bias=False),\n",
    "                                  nn.BatchNorm2d(out_channel))\n",
    "        self.shortcut = nn.Sequential()\n",
    "        if in_channel != out_channel:\n",
    "            self.shortcut = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, padding=0, bias=False),\n",
    "                                          nn.BatchNorm2d(out_channel))\n",
    "    def forward(self, x):\n",
    "        identity = self.shortcut(x)\n",
    "        out = self.conv(x)\n",
    "        out += identity\n",
    "        out = F.relu(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4, 3, 32, 32]) torch.Size([4, 64, 16, 16])\n"
     ]
    }
   ],
   "source": [
    "block = Bottleneck(3, 64, 2)\n",
    "# print(block)\n",
    "x = torch.randn(4, 3, 32, 32)\n",
    "y = block(x)\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet(nn.Module):\n",
    "    \"\"\"ResNet\"\"\"\n",
    "    def __init__(self, block, n_classes=10):\n",
    "        super().__init__()\n",
    "        self.block = block\n",
    "        self.prev = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),\n",
    "                                  nn.BatchNorm2d(64),\n",
    "                                  nn.ReLU(inplace=True))\n",
    "        \n",
    "        self.layer1 = self._make_layer(block, 64, 64, 2, stride=1)\n",
    "        self.layer2 = self._make_layer(block, 64, 128, 2, stride=2)\n",
    "        self.layer3 = self._make_layer(block, 128, 256, 2, stride=2)\n",
    "        self.layer4 = self._make_layer(block, 256, 512, 2, stride=2)\n",
    "        self.avg = nn.AvgPool2d(4)\n",
    "        self.classifier = nn.Sequential(nn.Linear(512, n_classes))\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'{self.__doc__} with {self.block.__doc__}'\n",
    "        \n",
    "    def _make_layer(self, block, in_channel, out_channel, n_blocks, stride):\n",
    "        layers = []\n",
    "        \n",
    "        layers.append(block(in_channel, out_channel, stride=stride))\n",
    "        \n",
    "        for _ in range(1, n_blocks):\n",
    "            layers.append(block(out_channel, out_channel, stride=1))\n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out = self.prev(x)\n",
    "        out = self.layer1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        out = self.avg(out)\n",
    "        out = out.view(out.shape[0], -1)\n",
    "        out = self.classifier(out)\n",
    "        return out     \n",
    "    \n",
    "#     def forward_test(self, x):\n",
    "#         print(f\"{'input':<20}{str(x.shape):<40}\")\n",
    "#         for name, module in self._modules.items():\n",
    "#               x = module(x)\n",
    "#               print(f\"{name:<20}{str(x.shape):<40}\")\n",
    "#         return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ResNet(ResidualBlock, 10)\n",
    "# print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 10])\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(1, 3, 32, 32)\n",
    "y = model(x)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset\n",
    "\n",
    "MNIST:如果吃力就改用手写数字识别系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import datasets\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                                     std=[0.229, 0.224, 0.225])])\n",
    "trainset = datasets.CIFAR10(root='./data',\n",
    "                            train=True,\n",
    "                            download=True,\n",
    "                            transform=transform)\n",
    "trainloader = DataLoader(trainset,\n",
    "                         batch_size=4,\n",
    "                         shuffle=True,\n",
    "                         num_workers=2)\n",
    "testset = datasets.CIFAR10(root='./data',\n",
    "                           train=False,\n",
    "                           download=True,\n",
    "                           transform=transform)\n",
    "testloader = DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)\n",
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck'\n",
    "]\n",
    "\n",
    "\n",
    "def plot_images(images, cls_true, cls_pred=None):\n",
    "    \"\"\"\n",
    "    Adapted from https://github.com/Hvass-Labs/TensorFlow-Tutorials/\n",
    "    \"\"\"\n",
    "    fig, axes = plt.subplots(3, 3)\n",
    "\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # plot img\n",
    "        ax.imshow(images[i, :, :, :], interpolation='spline16')\n",
    "\n",
    "        # show true & predicted classes\n",
    "        cls_true_name = label_names[cls_true[i]]\n",
    "        if cls_pred is None:\n",
    "            xlabel = f\"{cls_true_name} ({cls_true[i]})\"\n",
    "        else:\n",
    "            cls_pred_name = label_names[cls_pred[i]]\n",
    "            xlabel = \"True: {cls_true_name}\\nPred: {cls_pred_name}\"\n",
    "        ax.set_xlabel(xlabel)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "#     plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "\n",
    "\n",
    "def get_train_valid_loader(data_dir,\n",
    "                           batch_size,\n",
    "                           random_seed,\n",
    "                           valid_ratio=0.1,\n",
    "                           shuffle=True,\n",
    "                           show_sample=False,\n",
    "                           num_workers=4,\n",
    "                           pin_memory=False):\n",
    "    \"\"\"\n",
    "    Utility function for loading and returning train and valid\n",
    "    multi-process iterators over the CIFAR-10 dataset. A sample\n",
    "    9x9 grid of the images can be optionally displayed.\n",
    "    If using CUDA, num_workers should be set to 1 and pin_memory to True.\n",
    "    \n",
    "    Params\n",
    "    ------\n",
    "    - data_dir: path directory to the dataset.\n",
    "    - batch_size: how many samples per batch to load.\n",
    "      mentioned in the paper. Only applied on the train split.\n",
    "    - random_seed: fix seed for reproducibility.\n",
    "    - valid_ratio: percentage split of the training set used for\n",
    "      the validation set. Should be a float in the range [0, 1].\n",
    "    - shuffle: whether to shuffle the train/validation indices.\n",
    "    - show_sample: plot 9x9 sample grid of the dataset.\n",
    "    - num_workers: number of subprocesses to use when loading the dataset.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - train_loader: training set iterator.\n",
    "    - valid_loader: validation set iterator.\n",
    "    \"\"\"\n",
    "\n",
    "    # define transforms\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\n",
    "    ])\n",
    "\n",
    "    # load the dataset\n",
    "    train_set = datasets.CIFAR10(\n",
    "        root=data_dir, train=True,\n",
    "        download=True, transform=transform,\n",
    "    )\n",
    "\n",
    "    valid_set = datasets.CIFAR10(\n",
    "        root=data_dir, train=True,\n",
    "        download=True, transform=transform,\n",
    "    )\n",
    "\n",
    "    num_train = len(train_set)\n",
    "    indices = list(range(num_train))\n",
    "    split = int(np.floor(valid_ratio * num_train))\n",
    "\n",
    "    if shuffle:\n",
    "        np.random.seed(random_seed)\n",
    "        np.random.shuffle(indices)\n",
    "\n",
    "    train_idx, valid_idx = indices[split:], indices[:split]\n",
    "    train_sampler = SubsetRandomSampler(train_idx)\n",
    "    valid_sampler = SubsetRandomSampler(valid_idx)\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_set, batch_size=batch_size, \n",
    "        sampler=train_sampler, num_workers=num_workers\n",
    "    )\n",
    "    valid_loader = torch.utils.data.DataLoader(\n",
    "        valid_set, batch_size=batch_size, \n",
    "        sampler=valid_sampler, num_workers=num_workers\n",
    "    )\n",
    "\n",
    "    # visualize some images\n",
    "    if show_sample:\n",
    "        sample_loader = torch.utils.data.DataLoader(\n",
    "            train_set, batch_size=9, \n",
    "            shuffle=shuffle, num_workers=num_workers\n",
    "        )\n",
    "        data_iter = iter(sample_loader)\n",
    "        images, labels = data_iter.next()        \n",
    "        X = images.numpy().transpose([0, 2, 3, 1])\n",
    "        plot_images(X, labels)\n",
    "\n",
    "    return (train_loader, valid_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_loader, valid_loader = get_train_valid_loader('./data',\n",
    "                                                    batch_size=2,\n",
    "                                                    random_seed=123,\n",
    "                                                    valid_ratio=0.1,\n",
    "                                                    shuffle=True,\n",
    "                                                    show_sample=True,\n",
    "                                                    num_workers=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_test_loader(data_dir,\n",
    "                    batch_size,\n",
    "                    shuffle=True,\n",
    "                    num_workers=0):\n",
    "    \"\"\"\n",
    "    Utility function for loading and returning a multi-process\n",
    "    test iterator over the CIFAR-10 dataset.\n",
    "    If using CUDA, num_workers should be set to 1 and pin_memory to True.\n",
    "    \n",
    "    Params\n",
    "    ------\n",
    "    - data_dir: path directory to the dataset.\n",
    "    - batch_size: how many samples per batch to load.\n",
    "    - shuffle: whether to shuffle the dataset after every epoch.\n",
    "    - num_workers: number of subprocesses to use when loading the dataset.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    - data_loader: test set iterator.\n",
    "    \"\"\"\n",
    "    # define transform\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010]),\n",
    "    ])\n",
    "\n",
    "    dataset = datasets.CIFAR10(\n",
    "        root=data_dir, train=False,\n",
    "        download=True, transform=transform,\n",
    "    )\n",
    "\n",
    "    data_loader = torch.utils.data.DataLoader(\n",
    "        dataset, batch_size=batch_size, \n",
    "        shuffle=shuffle, num_workers=num_workers\n",
    "    )\n",
    "\n",
    "    return data_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "test_loader = get_test_loader(data_dir='./data',\n",
    "                              batch_size=2,\n",
    "                              shuffle=False,\n",
    "                              num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trainer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(state, is_best=None, save_dir=None):\n",
    "    last_model = os.path.join(save_dir, 'last_model.pth.tar')\n",
    "    torch.save(state, last_model)\n",
    "    if is_best:\n",
    "        best_model = os.path.join(save_dir, 'best_model.pth.tar')\n",
    "        shutil.copyfile(last_model, best_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer(object):\n",
    "    def __init__(self, args):\n",
    "        self.device  = args.device\n",
    "        \n",
    "        self.model = args.model\n",
    "        self.model_name = self.model.__class__.__name__\n",
    "        self.model_path = self._model_path()\n",
    "        \n",
    "        self.criterion = nn.CrossEntropyLoss()\n",
    "                \n",
    "        self.epochs = args.epochs\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=args.lr)\n",
    "        self.train_loader = args.train_loader\n",
    "        self.valid_loader = args.valid_loader\n",
    "    \n",
    "    def _model_path(self):\n",
    "        \"\"\"Path to save the model\"\"\"\n",
    "        if not os.path.exists('checkpoints'):\n",
    "            os.mkdir('checkpoints')\n",
    "\n",
    "        path = os.path.join('checkpoints', self.model_name)\n",
    "        if not os.path.exists(path):\n",
    "            os.mkdir(path)\n",
    "    \n",
    "        return path\n",
    "        \n",
    "    def train(self):\n",
    "        print('Start training ...')\n",
    "        \n",
    "        best_loss = 1.e10\n",
    "        for epoch in range(self.epochs):\n",
    "            running_loss = 0.0\n",
    "            for i, data in enumerate(self.train_loader):\n",
    "                inputs, labels = data\n",
    "            \n",
    "                self.optimizer.zero_grad()\n",
    "            \n",
    "                outputs = self.model(inputs)\n",
    "                loss = self.criterion(outputs, labels)\n",
    "                loss.backward()\n",
    "                self.optimizer.step()\n",
    "            \n",
    "                running_loss += loss.item()\n",
    "                if (i+1) % 2000 == 0:\n",
    "                    print(f\"[{epoch+1}, {i+1:5d}] loss: {running_loss / 2000: .3f}\")\n",
    "                    running_loss = 0.0   \n",
    "                    \n",
    "                valid_loss = self.valid()\n",
    "                is_best = valid_loss < best_loss\n",
    "                best_loss = valid_loss if is_best else best_loss\n",
    "                state = {'epoch': epoch, \n",
    "                        'state_dict': self.model.state_dict(),\n",
    "                        'best_loss': best_loss}\n",
    "                save_model(state, is_best, save_dir=self.model_path)                   \n",
    "        print('Finished training ...')\n",
    "        \n",
    "    def valid(self):\n",
    "        self.model.eval()\n",
    "        valid_loss = 0.0\n",
    "        for i, data in enumerate(self.valid_loader):\n",
    "            inputs, labels = data\n",
    "            outputs = self.model(inputs)\n",
    "            loss = self.criterion(outputs, labels)\n",
    "            valid_loss += loss.item()\n",
    "        return valid_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Options(object):\n",
    "    def __init__(self):\n",
    "        parser = argparse.ArgumentParser()\n",
    "        parser.add_argument('--no_cuda', action='store_true', default=False, help='disable CUDA or not')\n",
    "        parser.add_argument('--lr', type=float, default=1e-3, help='initial learning rate')\n",
    "        parser.add_argument('--epochs', type=int, default=10, help='epochs for optimizer')\n",
    "        \n",
    "        self.parser = parser\n",
    "    def parse(self):\n",
    "        arg = self.parser.parse_args(args=[])\n",
    "        arg.cuda = not arg.no_cuda and torch.cuda.is_available()\n",
    "        arg.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "args = Options().parse()\n",
    "args.train_loader, args.valid_loader = get_train_valid_loader('./data',\n",
    "                                                    batch_size=2,\n",
    "                                                    random_seed=123,\n",
    "                                                    valid_ratio=0.1,\n",
    "                                                    shuffle=True,\n",
    "                                                    show_sample=True,\n",
    "                                                    num_workers=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "args.model = ResNet(ResidualBlock, 10)\n",
    "trainer = Trainer(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(cuda=True, device=device(type='cuda'), epochs=10, lr=0.001, model=ResNet with ResidualBlock, no_cuda=False, train_loader=<torch.utils.data.dataloader.DataLoader object at 0x000001A3842F14A8>, valid_loader=<torch.utils.data.dataloader.DataLoader object at 0x000001A3842F1320>)\n"
     ]
    }
   ],
   "source": [
    "print(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainer.train()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
